// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_SPARSE_TRIANGULARVIEW_H
#define EIGEN_SPARSE_TRIANGULARVIEW_H

namespace Eigen {

/** \ingroup SparseCore_Module
  *
  * \brief Base class for a triangular part in a \b sparse matrix
  *
  * This class is an abstract base class of class TriangularView, and objects of type TriangularViewImpl cannot be instantiated.
  * It extends class TriangularView with additional methods which are available for sparse expressions only.
  *
  * \sa class TriangularView, SparseMatrixBase::triangularView()
  */
template <typename MatrixType, unsigned int Mode> class TriangularViewImpl<MatrixType, Mode, Sparse> : public SparseMatrixBase<TriangularView<MatrixType, Mode>>
{
    enum
    {
        SkipFirst = ((Mode & Lower) && !(MatrixType::Flags & RowMajorBit)) || ((Mode & Upper) && (MatrixType::Flags & RowMajorBit)),
        SkipLast = !SkipFirst,
        SkipDiag = (Mode & ZeroDiag) ? 1 : 0,
        HasUnitDiag = (Mode & UnitDiag) ? 1 : 0
    };

    typedef TriangularView<MatrixType, Mode> TriangularViewType;

protected:
    // dummy solve function to make TriangularView happy.
    void solve() const;

    typedef SparseMatrixBase<TriangularViewType> Base;

public:
    EIGEN_SPARSE_PUBLIC_INTERFACE(TriangularViewType)

    typedef typename MatrixType::Nested MatrixTypeNested;
    typedef typename internal::remove_reference<MatrixTypeNested>::type MatrixTypeNestedNonRef;
    typedef typename internal::remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned;

    template <typename RhsType, typename DstType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _solve_impl(const RhsType& rhs, DstType& dst) const
    {
        if (!(internal::is_same<RhsType, DstType>::value && internal::extract_data(dst) == internal::extract_data(rhs)))
            dst = rhs;
        this->solveInPlace(dst);
    }

    /** Applies the inverse of \c *this to the dense vector or matrix \a other, "in-place" */
    template <typename OtherDerived> void solveInPlace(MatrixBase<OtherDerived>& other) const;

    /** Applies the inverse of \c *this to the sparse vector or matrix \a other, "in-place" */
    template <typename OtherDerived> void solveInPlace(SparseMatrixBase<OtherDerived>& other) const;
};

namespace internal {

    template <typename ArgType, unsigned int Mode>
    struct unary_evaluator<TriangularView<ArgType, Mode>, IteratorBased> : evaluator_base<TriangularView<ArgType, Mode>>
    {
        typedef TriangularView<ArgType, Mode> XprType;

    protected:
        typedef typename XprType::Scalar Scalar;
        typedef typename XprType::StorageIndex StorageIndex;
        typedef typename evaluator<ArgType>::InnerIterator EvalIterator;

        enum
        {
            SkipFirst = ((Mode & Lower) && !(ArgType::Flags & RowMajorBit)) || ((Mode & Upper) && (ArgType::Flags & RowMajorBit)),
            SkipLast = !SkipFirst,
            SkipDiag = (Mode & ZeroDiag) ? 1 : 0,
            HasUnitDiag = (Mode & UnitDiag) ? 1 : 0
        };

    public:
        enum
        {
            CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
            Flags = XprType::Flags
        };

        explicit unary_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_arg(xpr.nestedExpression()) {}

        inline Index nonZerosEstimate() const { return m_argImpl.nonZerosEstimate(); }

        class InnerIterator : public EvalIterator
        {
            typedef EvalIterator Base;

        public:
            EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& xprEval, Index outer)
                : Base(xprEval.m_argImpl, outer), m_returnOne(false), m_containsDiag(Base::outer() < xprEval.m_arg.innerSize())
            {
                if (SkipFirst)
                {
                    while ((*this) && ((HasUnitDiag || SkipDiag) ? this->index() <= outer : this->index() < outer)) Base::operator++();
                    if (HasUnitDiag)
                        m_returnOne = m_containsDiag;
                }
                else if (HasUnitDiag && ((!Base::operator bool()) || Base::index() >= Base::outer()))
                {
                    if ((!SkipFirst) && Base::operator bool())
                        Base::operator++();
                    m_returnOne = m_containsDiag;
                }
            }

            EIGEN_STRONG_INLINE InnerIterator& operator++()
            {
                if (HasUnitDiag && m_returnOne)
                    m_returnOne = false;
                else
                {
                    Base::operator++();
                    if (HasUnitDiag && (!SkipFirst) && ((!Base::operator bool()) || Base::index() >= Base::outer()))
                    {
                        if ((!SkipFirst) && Base::operator bool())
                            Base::operator++();
                        m_returnOne = m_containsDiag;
                    }
                }
                return *this;
            }

            EIGEN_STRONG_INLINE operator bool() const
            {
                if (HasUnitDiag && m_returnOne)
                    return true;
                if (SkipFirst)
                    return Base::operator bool();
                else
                {
                    if (SkipDiag)
                        return (Base::operator bool() && this->index() < this->outer());
                    else
                        return (Base::operator bool() && this->index() <= this->outer());
                }
            }

            //       inline Index row() const { return (ArgType::Flags&RowMajorBit ? Base::outer() : this->index()); }
            //       inline Index col() const { return (ArgType::Flags&RowMajorBit ? this->index() : Base::outer()); }
            inline StorageIndex index() const
            {
                if (HasUnitDiag && m_returnOne)
                    return internal::convert_index<StorageIndex>(Base::outer());
                else
                    return Base::index();
            }
            inline Scalar value() const
            {
                if (HasUnitDiag && m_returnOne)
                    return Scalar(1);
                else
                    return Base::value();
            }

        protected:
            bool m_returnOne;
            bool m_containsDiag;

        private:
            Scalar& valueRef();
        };

    protected:
        evaluator<ArgType> m_argImpl;
        const ArgType& m_arg;
    };

}  // end namespace internal

template <typename Derived> template <int Mode> inline const TriangularView<const Derived, Mode> SparseMatrixBase<Derived>::triangularView() const
{
    return TriangularView<const Derived, Mode>(derived());
}

}  // end namespace Eigen

#endif  // EIGEN_SPARSE_TRIANGULARVIEW_H
